//
// Description: 鸭鸭的数列
// Created by Loading on 2021/3/26.
//

// 鸭鸭写出了一个长长的单调递增整数数列，但雪球始终不太满意，他会反复给出数列中的区间，让鸭鸭把这个区间对应的数列替换成一个“相似数列”。相似数列的定义是：
// 都要单调递增
// 两个数列长度相同
// 所有数字都是1到k之间（包含）的整数
// 两个数列有且仅有1个位置数字不同
// 你需要帮鸭鸭算一算，一共有多少个这样的“相似数列”。

// Input
// 第一行是三个整数，n表示鸭鸭最初写的数列长度，q表示雪球给了多少个区间，k表示数列中的数字最大值。(1<=n,q<=10^5, n<=k<=10^9)
// 第二行是a1 … an表示数列中的每一个数(1<=ai<=k)，是单调递增的
// 后续q行每行两个整数 li, ri (1<=li<=ri<=n)，表示区间下标的左右端点
//
// Output
// 给出q行输出，对应每个区间下，你为鸭鸭计算出的“相似数列”个数

// Examples
//
// Input
// 6 3 11
// 3 5 7 8 9 10
// 3 5
// 5 5
// 1 4
//
// Output
// 8
// 10
// 9

// Input
// 6 5 10
// 2 4 6 7 8 9
// 1 4
// 1 2
// 3 5
// 1 6
// 5 5
//
// Output
// 8
// 9
// 7
// 6
// 9

#include <bits/stdc++.h>

using namespace std;

int calc(int l, int r, int start, int end) {
    if(l > r){
        return 0;
    }

    return end - start - 2;
}

int main() {
    int n, q, k;
    cin >> n >> q >> k;
    vector<int> vec(n);
    for (auto &x : vec) {
        cin >> x;
    }
    vector<pair<int, int>> interval;
    for (int i = 0; i < q; ++i) {
        pair<int, int> p;
        cin >> p.first >> p.second;
        interval.emplace_back(p);
    }

    for (auto &p : interval) {
        int sum = 0;
        if (p.first == p.second) {//区间长度为1
            cout << k - 1 << endl;
            continue;
        }

//        //暴力计算，TLE
//        for (int i = p.first - 1; i <= p.second - 1; ++i) {
//            if (i == p.first - 1) {
//                sum += vec[i + 1] - 2;
//            } else if (i == p.second - 1) {
//                sum += k - vec[i - 1] - 1;
//            } else {
//                sum += vec[i + 1] - vec[i - 1] - 2;
//            }
//        }

        sum += vec[p.first] - 2;            //改变左端点
        sum += k - vec[p.second - 2] - 1;   //改变右端点
        //区间长度大于2
        if(p.second - p.first > 1) {
            //计算除去两个端点的其他数
            //推导过程：
            //令 i = p.first，则左边第二个的数的可替换的个数为：vec[i] - vec[i - 1] - 1 + vec[i + 1] - vec[i] - 1
            //左边第三个数的课替换的个数为：vec[i + 1] + vec[i] - 1 + vec[i + 2] - vec[i + 1] - 1
            //一直计算到倒数第二个数。中间会有抵消现象，累计结果为：
            //vec[p.second - 1] + vec[p.second - 2] - vec[p.first] - vec[p.first - 1] - 2 * (p.second - p.first - 1)
            sum += vec[p.second - 1] + vec[p.second - 2] - vec[p.first] - vec[p.first - 1] - 2 * (p.second - p.first - 1);
        }

        cout << sum << endl;
    }
}